home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / alpha.arc / AX25DUMP.C < prev    next >
C/C++ Source or Header  |  1988-02-16  |  6KB  |  263 lines
  1. #include <stdio.h>
  2. #include "global.h"
  3. #include "mbuf.h"
  4. #include "ax25.h"
  5. #include "timer.h"
  6. #include "lapb.h"
  7. #include "trace.h"
  8.  
  9. /* Dump an AX.25 packet header */
  10. ax25_dump(bpp,check)
  11. struct mbuf **bpp;
  12. int check;    /* Not used */
  13. {
  14.     char *decode_type();
  15.     char tmp[20];
  16.     char control,pid;
  17.     int16 type,ftype();
  18.     struct ax25 hdr;
  19.     struct ax25_addr *hp;
  20.  
  21.     printf("AX25: ");
  22.     /* Extract the address header */
  23.     if(ntohax25(&hdr,bpp) < 0){
  24.         /* Something wrong with the header */
  25.         printf(" bad header!\n");
  26.         return;
  27.     }
  28.     pax25(tmp,&hdr.source);
  29.     printf("%s",tmp);
  30.     pax25(tmp,&hdr.dest);
  31.     printf("->%s",tmp);
  32.     if(hdr.ndigis > 0){
  33.         printf(" v");
  34.         for(hp = &hdr.digis[0]; hp < &hdr.digis[hdr.ndigis]; hp++){
  35.             /* Print digi string */
  36.             pax25(tmp,hp);
  37.             printf(" %s%s",tmp,(hp->ssid & REPEATED) ? "*":"");
  38.         }
  39.     }
  40.     if(pullup(bpp,&control,1) != 1)
  41.         return;
  42.  
  43.     putchar(' ');
  44.     type = ftype(control);
  45.     printf("%s",decode_type(type));
  46.     /* Dump poll/final bit */
  47.     if(control & PF){
  48.         switch(hdr.cmdrsp){
  49.         case COMMAND:
  50.             printf("(P)");
  51.             break;
  52.         case RESPONSE:
  53.             printf("(F)");
  54.             break;
  55.         default:
  56.             printf("(P/F)");
  57.             break;
  58.         }
  59.     }
  60.     /* Dump sequence numbers */
  61.     if((type & 0x3) != U)    /* I or S frame? */
  62.         printf(" NR=%d",(control>>5)&7);
  63.     if(type == I || type == UI){    
  64.         if(type == I)
  65.             printf(" NS=%d",(control>>1)&7);
  66.         /* Decode I field */
  67.         if(pullup(bpp,&pid,1) == 1){    /* Get pid */
  68.             switch(pid & (PID_FIRST | PID_LAST)){
  69.             case PID_FIRST:
  70.                 printf(" First frag");
  71.                 break;
  72.             case PID_LAST:
  73.                 printf(" Last frag");
  74.                 break;
  75.             case PID_FIRST|PID_LAST:
  76.                 break;    /* Complete message, say nothing */
  77.             case 0:
  78.                 printf(" Middle frag");
  79.                 break;
  80.             }
  81.             printf(" pid=");
  82.             switch(pid & 0x3f){
  83.             case PID_ARP:
  84.                 printf("ARP\n");
  85.                 break;
  86.             case PID_NETROM:
  87.                 printf("NET/ROM\n");
  88.                 break;
  89.             case PID_IP:
  90.                 printf("IP\n");
  91.                 break;
  92.             case PID_NO_L3:
  93.                 printf("Text\n");
  94.                 break;
  95.             default:
  96.                 printf("0x%x\n",pid);
  97.             }
  98.             /* Only decode frames that are the first in a
  99.              * multi-frame sequence
  100.              */
  101.             switch(pid & (PID_PID | PID_FIRST)){
  102.             case PID_ARP | PID_FIRST:
  103.                 arp_dump(bpp);
  104.                 break;
  105.             case PID_IP | PID_FIRST:
  106.                 /* Only checksum complete frames */
  107.                 ip_dump(bpp,pid & PID_LAST);
  108.                 break;
  109.             case PID_NETROM | PID_FIRST:
  110.                 netrom_dump(bpp);
  111.                 break;
  112.             }
  113.         }
  114.     } else if(type == FRMR && pullup(bpp,tmp,3) == 3){
  115.         printf(": %s",decode_type(ftype(tmp[0])));
  116.         printf(" Vr = %d Vs = %d",(tmp[1] >> 5) & MMASK,
  117.             (tmp[1] >> 1) & MMASK);
  118.         if(tmp[2] & W)
  119.             printf(" Invalid control field");
  120.         if(tmp[2] & X)
  121.             printf(" Illegal I-field");
  122.         if(tmp[2] & Y)
  123.             printf(" Too-long I-field");
  124.         if(tmp[2] & Z)
  125.             printf(" Invalid seq number");
  126.         printf("\n");
  127.     } else
  128.         printf("\n");
  129.  
  130.     fflush(stdout);
  131. }
  132. /* Display NET/ROM network and transport headers */
  133. static
  134. netrom_dump(bpp)
  135. struct mbuf **bpp;
  136. {
  137.     struct ax25_addr src,dest;
  138.     char x;
  139.     char tmp[16];
  140.     char thdr[5];
  141.     register i;
  142.  
  143.     if(bpp == NULLBUFP || *bpp == NULLBUF)
  144.         return;
  145.     /* See if it is a routing broadcast */
  146.     if(uchar(*(*bpp)->data) == 0xff) {
  147.         pullup(bpp,tmp,1);        /* Signature */
  148.         pullup(bpp,tmp,ALEN);
  149.         tmp[ALEN] = '\0';
  150.         printf("NET/ROM Routing: %s\n",tmp);
  151.         for(i = 0;i < 11;i++) {
  152.             if (pullup(bpp,tmp,AXALEN) < AXALEN)
  153.                 break;
  154.             memcpy(src.call,tmp,ALEN);
  155.             src.ssid = tmp[ALEN];
  156.             pax25(tmp,&src);
  157.             printf("        %12s",tmp);
  158.             pullup(bpp,tmp,ALEN);
  159.             tmp[ALEN] = '\0';
  160.             printf("%8s",tmp);
  161.             pullup(bpp,tmp,AXALEN);
  162.             memcpy(src.call,tmp, ALEN);
  163.             src.ssid = tmp[ALEN];
  164.             pax25(tmp,&src);
  165.             printf("    %12s", tmp);
  166.             pullup(bpp,tmp,1);
  167.             printf("    %3u\n", (unsigned)tmp[0]);
  168.         }
  169.         return;
  170.     }
  171.     /* Decode network layer */
  172.     pullup(bpp,tmp,AXALEN);
  173.     memcpy(src.call,tmp,ALEN);
  174.     src.ssid = tmp[ALEN];
  175.     pax25(tmp,&src);
  176.     printf("NET/ROM: %s",tmp);
  177.  
  178.     pullup(bpp,tmp,AXALEN);
  179.     memcpy(dest.call,tmp,ALEN);
  180.     dest.ssid = tmp[ALEN];
  181.     pax25(tmp,&dest);
  182.     printf("->%s",tmp);
  183.  
  184.     pullup(bpp,&x,1);
  185.     printf(" ttl %d\n",uchar(x));
  186.  
  187.     printf("         ");
  188.     /* Read first five bytes of "transport" header */
  189.     pullup(bpp,thdr,5);
  190.     switch(thdr[4] & 0xf){
  191.     case 1:    /* Connect request */
  192.         printf("conn rqst: ckt %d/%d",uchar(thdr[0]),uchar(thdr[1]));
  193.         pullup(bpp,&x,1);
  194.         printf(" wnd %d",x);
  195.         pullup(bpp,(char *)&src,sizeof(struct ax25_addr));
  196.         pax25(tmp,&src);
  197.         printf(" %s",tmp);
  198.         pullup(bpp,(char *)&dest,sizeof(struct ax25_addr));
  199.         pax25(tmp,&dest);
  200.         printf("->%s",tmp);
  201.         break;
  202.     case 2:    /* Connect acknowledgement */
  203.         printf("conn ack: ur ckt %d/%d my ckt %d/%d",
  204.             uchar(thdr[0]), uchar(thdr[1]), uchar(thdr[2]),
  205.             uchar(thdr[3]));
  206.         pullup(bpp,&x,1);
  207.         printf(" wnd %d",x);
  208.         break;
  209.     case 3:    /* Disconnect request */
  210.         printf("disc: ckt %d/%d",uchar(thdr[0]),uchar(thdr[1]));
  211.         break;
  212.     case 4:    /* Disconnect acknowledgement */
  213.         printf("disc ack: ckt %d/%d",uchar(thdr[0]),uchar(thdr[1]));
  214.         break;
  215.     case 5:    /* Information (data) */
  216.         printf("info: ckt %d/%d",uchar(thdr[0]),uchar(thdr[1]));
  217.         printf(" txseq %d rxseq %d",uchar(thdr[2]), uchar(thdr[3]));
  218.         break;
  219.     case 6:    /* Information acknowledgement */
  220.         printf("info ack: ckt %d/%d",uchar(thdr[0]),uchar(thdr[1]));
  221.         printf(" txseq %d rxseq %d",uchar(thdr[2]), uchar(thdr[3]));
  222.         break;
  223.     default:
  224.         printf("(unknown type)");
  225.         break;
  226.     }
  227.     if(thdr[4] & 0x80)
  228.         printf(" CHOKE");
  229.     if(thdr[4] & 0x40)
  230.         printf(" NAK");
  231.     printf("\n");
  232. }
  233. char *
  234. decode_type(type)
  235. int16 type;
  236. {
  237.     switch(uchar(type)){
  238.     case I:
  239.         return "I";
  240.     case SABM:
  241.         return "SABM";
  242.     case DISC:
  243.         return "DISC";
  244.     case DM:
  245.         return "DM";
  246.     case UA:
  247.         return "UA";
  248.     case RR:
  249.         return "RR";
  250.     case RNR:
  251.         return "RNR";
  252.     case REJ:
  253.         return "REJ";
  254.     case FRMR:
  255.         return "FRMR";
  256.     case UI:
  257.         return "UI";
  258.     default:
  259.         return "[invalid]";
  260.     }
  261. }
  262.  
  263.